import {
  checkAllCart,
  deleteCart,
  findCartList,
  getNewCartGoods,
  insertCart,
  mergeLocalCart,
  updateCart
} from '@/api/cart'
export default {
  namespaced: true,
  state: {
    // 存放购物车的列表
    list: []
  },
  mutations: {
    // 加入购物车
    /*
    payload的参数
    id: 商品的id
    name: 商品的名字
    picture: 商品的图片
    price： 加入时的价格
    count: 加入购物车的商品的数量
    skuId： 选择的商品的sku
    attrsText: 商品的规格的字符串  颜色：蓝色 尺寸：30cm
    selected: 商品是否选中
    nowPrice： 商品最新的价格
    stock： 商品的库存
    isEffective： 商品是否有效

    1. 判断payload中的skuId在list中是否存在
    2. 如果有，就把数量加上，，，把这件商品放到最上面
    3. 如果没有，就把这个商品放到列表的最前面。
  */
    insertCart(state, payload) {
      const index = state.list.findIndex(item => item.skuId === payload.skuId)
      if (index > -1) {
        // 说明购物车中已经有相同的商品
        payload.count = state.list[index].count + payload.count
        // 把购物车中那件商品给删除
        state.list.splice(index, 1)
      }
      state.list.unshift(payload)
    },
    // 更新购物车商品信息
    updateCart(state, goods) {
      // console.log(goods)
      const sku = state.list.find(item => item.skuId === goods.skuId)
      // console.log(goods)
      for (const k in goods) {
        // 遍历goods对象
        if (goods[k] !== null && goods[k] !== undefined && goods[k] !== '') {
          sku[k] = goods[k]
        }
      }
      // sku.isEffective = goods.isEffective
      // sku.nowPrice = goods.nowPrice
      // sku.stock = goods.stock
    },
    deleteCart(state, skuId) {
      // 删除购物车中对应的商品
      const index = state.list.findIndex(item => item.skuId === skuId)
      state.list.splice(index, 1)
    },
    changeAll(state, selected) {
      state.list.forEach(item => {
        item.selected = selected
      })
    },
    setCartList(state, list) {
      state.list = list
    }
  },
  actions: {
    insertCart(context, payload) {
      return new Promise((resolve, reject) => {
        // 判断用户是否登录，如果用户登录，发送请求，，否则提交mutaions
        if (context.rootState.user.profile.token) {
          // 用户登录账号
          insertCart({ skuId: payload.skuId, count: payload.count }).then(
            () => {
              // 插入成功, 重新发请求，获取最新的购物车数据
              context.dispatch('updateCart')
              resolve()
            }
          )
        } else {
          context.commit('insertCart', payload)
          resolve()
        }
      })
    },
    updateCart(context) {
      // 发送请求，更新购物车中所有的商品信息
      return new Promise((resolve, reject) => {
        if (context.rootState.user.profile.token) {
          // 登录了
          // 发送请求，获取在线的购物车数据
          findCartList().then(res => {
            context.commit('setCartList', res.result)
            resolve()
          })
        } else {
          // 没有登录，需要发送请求进行商品信息更新
          const requestArr = context.state.list.map(item => {
            return getNewCartGoods(item.skuId)
          })
          Promise.all(requestArr).then(res => {
            res.forEach((item, index) => {
              context.commit('updateCart', {
                skuId: context.state.list[index].skuId,
                ...item.result
              })
            })
            resolve()
          })
        }
      })
    },
    deleteCart(context, skuId) {
      return new Promise((resolve, reject) => {
        if (context.rootState.user.profile.token) {
          // TODO
          deleteCart([skuId]).then(() => {
            context.dispatch('updateCart')
            resolve()
          })
        } else {
          // 没登录
          context.commit('deleteCart', skuId)
          resolve()
        }
      })
    },
    updateChange(context, payload) {
      return new Promise((resolve, reject) => {
        if (context.rootState.user.profile.token) {
          // TODO 发送请求
          updateCart(payload).then(() => {
            context.dispatch('updateCart')
            resolve()
          })
        } else {
          context.commit('updateCart', payload)
          resolve()
        }
      })
    },
    changeAll(context, selected) {
      // 判断是否登录
      if (context.rootState.user.profile.token) {
        // TODO
        const ids = context.getters.validList.map(item => item.skuId)
        checkAllCart({
          ids,
          selected
        }).then(() => {
          context.dispatch('updateCart')
        })
      } else {
        context.commit('changeAll', selected)
      }
    },
    // 批量删除
    batchDeleteCart(context, isClear) {
      return new Promise((resolve, reject) => {
        if (context.rootState.user.profile.token) {
          // TODO
          const ids = context.getters[
            isClear ? 'invalidList' : 'selectedList'
          ].map(item => item.skuId)
          deleteCart(ids).then(() => {
            context.dispatch('updateCart')
            resolve()
          })
        } else {
          // 批量删除
          context.getters[isClear ? 'invalidList' : 'selectedList'].forEach(
            item => {
              context.commit('deleteCart', item.skuId)
            }
          )
        }
      })
    },
    updateCartSku(context, { oldSkuId, sku }) {
      return new Promise((resolve, reject) => {
        if (context.rootState.user.profile.token) {
          // 3. 重新发请求渲染
          const oldSku = context.state.list.find(
            item => item.skuId === oldSkuId
          )
          // 1. 发请求删除旧的sku
          deleteCart([oldSkuId]).then(() => {
            // 2. 发请求新增新的sku,,,,count是旧的sku的数量
            context.dispatch('insertCart', {
              skuId: sku.id,
              count: oldSku.count
            })
          })
        } else {
          // 1. 先根据oldSkuId找到旧的那件商品信息
          // debugger
          const oldSku = context.state.list.find(
            item => item.skuId === oldSkuId
          )
          // 2. 删除旧的商品信息
          context.commit('deleteCart', oldSkuId)
          // 3. 合并新的sku和老的sku的信息
          const newSku = {
            ...oldSku,
            skuId: sku.id,
            stock: sku.inventory,
            nowPrice: sku.price,
            price: sku.price,
            attrsText: sku.specs.reduce(
              (p, v) => `${p} ${v.name}: ${v.valueName}`,
              ''
            )
          }
          // 4. 插入新的sku
          context.commit('insertCart', newSku)
          // 5. 成功
          resolve()
        }
      })
    },
    // 合并购物车信息
    async mergeLocalCart(context) {
      const cartList = context.getters.validList.map(item => {
        return {
          skuId: item.skuId,
          count: item.count,
          selected: item.selected
        }
      })
      // console.log(cartList)
      await mergeLocalCart(cartList)
      // 清空购物车列表
      context.commit('setCartList', [])
    }
  },
  getters: {
    // 有效的商品列表
    validList(state) {
      // 有效的商品列表： 1. 库存>0 2. isEffective: false
      return state.list.filter(item => item.stock > 0 && item.isEffective)
    },
    // 统计有效的商品的数量
    validTotal(state, getters) {
      return getters.validList.reduce((p, v) => p + v.count, 0)
    },
    validAmount(state, getters) {
      return getters.validList
        .reduce((p, v) => p + v.nowPrice * v.count, 0)
        .toFixed(2)
    },
    // 无效的商品列表
    invalidList(state) {
      return state.list.filter(item => !(item.stock > 0 && item.isEffective))
    },
    // 选中的商品列表
    selectedList(state) {
      return state.list.filter(item => item.selected)
    },
    // 选中的商品数量
    selectedTotal(state, getters) {
      return getters.selectedList.reduce((p, v) => p + v.count, 0)
    },
    // 选中的商品价格,
    selectedAmount(state, getters) {
      return getters.selectedList.reduce((p, v) => p + v.nowPrice * v.count, 0)
    },
    selectedAll(state, getters) {
      return getters.selectedList.length === getters.validList.length
    }
  }
}
